home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / program / cgazv4n2.zip / EXPANDWI.C < prev    next >
Text File  |  1989-11-03  |  25KB  |  567 lines
  1. /********************************** EXPANDWI.C ********************************
  2. *    Expand wildcard file names in a "ragged" string array into a new array.
  3. *
  4. *    SYNOPSIS:   int expandwild(pnOut, pvOut, nIn, vIn, attrib) 
  5. *
  6. *    nIn: no. of strings in vIn; if < 0, stop when vIn[i] == NULL.
  7. *
  8. *    vIn: array of pointers to strings, e.g., argv. Wildcard strings
  9. *         expanded to full file name and path in *pvOut, all strings which
  10. *         don't expand are copied unchanged.
  11. *
  12. *   attrib: attribute byte of files to be returned, see FA_xxxxxx constants.
  13. *
  14. *   pnOut: points to int to return no. of strings in pvOut.
  15. * 
  16. *   pvOut: points to pointer to output array, *pvOut[*pnOut] == NULL.
  17. *
  18. *   Return value: 0 if successful, non-0 (see codes below) if errors.
  19. *
  20. *   AUTHOR: Bill Lee, 5132 106A St., Edmonton, Alberta, Canada T6H 2W7
  21. *       CompuServe 70441,2372.
  22. *
  23. *   Copyright (C) by Bill Lee, 1989. All rights reserved.
  24. *   Use freely for any non-military purpose but retain copyright notice.
  25. *
  26. *   COMPILATION OPTIONS:    All memory models of two compilers are supported;
  27. *   for your compiler, define the appropriate constant if needed:
  28. *   +   (none, the assumed default): Microsoft C 5.1 for DOS only.
  29. *   +   OS2:  With Microsoft C 5.1, use OS/2 v1.1 family API (FAPI) for the
  30. *       find-file functions; can then be "bound" to run under DOS or under
  31. *       protected mode. Header files from Microsoft OS/2 Presentation Manager
  32. *       Toolkit v1.1 needed. expandwi.c is probably re-entrant for
  33. *       multithreading but not tested.
  34. *   +   (none, detects __TURBOC__):  Turbo C 2.0 under DOS.
  35. *   +   Define MAIN to generate a main() test driver.
  36. *
  37. *   VERSION:  1.1, 89aug26.
  38. ***************************************************************************/
  39.  
  40. #if defined(__TURBOC__)
  41. #include <string.h>
  42. #include <stdio.h>
  43. #include <dos.h>
  44. #include <alloc.h>
  45.  
  46. /*  Normally, dir.h is included for the prototypes of findfirst()
  47.     and findnext(), but it was necessary to code them below with a
  48.     modification for the MSC structure name which is used here. */
  49.  
  50. int _Cdecl findfirst(char *, struct find_t *, int);
  51. int _Cdecl findnext(struct find_t *);
  52.  
  53. /*  MSC 5.1 and TurboC 2.0 provide the directory find-first and find-next
  54.     file functions in slightly different flavours; the following macros
  55.     adapt the MSC DOS functions calls for use with the TurboC RTL.        */
  56.  
  57. #define _dos_findfirst(path, attr, buff)    findfirst((path), (buff), (attr))
  58. #define _dos_findnext(buff)                 findnext((buff))
  59.  
  60. /*  Structure used by _dos_findfirst() and _dos_findnext(), a-la MSC  */
  61. struct find_t {
  62.     char reserved[21];                  /* workarea */
  63.     char attrib;                        /* file attribute bit flags */
  64.     unsigned int wr_time;               /* packed time of last file write */
  65.     unsigned int wr_date;               /* packed date of last file write */
  66.     long size;                          /* file size */
  67.     char name[13];                      /* file name.ext, no blanks */
  68. };
  69.  
  70. #else                                   /* MSC */
  71.  
  72. #include <stdio.h>
  73. #include <stddef.h>
  74. #include <string.h>
  75. #include <malloc.h>
  76. #if !defined(OS2)
  77. #include <dos.h>                        /* _dos_findfirst/_dos_findnext */
  78. #else
  79. #define INCL_DOSFILEMGR                 /* OS/2 file mgmt */
  80. #define INCL_DOSMISC                    /* for DosGetMachineMode() */
  81. #define INCL_NOPM                       /* save compile time, exclude PM */
  82. #include <os2.h>                        /* MS Pres Mgr Toolkit */
  83. #endif  /* #if !defined(OS2) */
  84.  
  85. /*  MSC lacks Turbo C's stpcpy(); this macro is an adequate
  86.     replacement for non-overlapping src and dest.  */
  87.  
  88. #define stpcpy(dest, src)   (strcpy((dest), (src)) + strlen(src))
  89.  
  90. #endif  /* #if defined(__TURBOC__) */
  91.  
  92. /*  Maximum lengths of fnsplitE() input and output strings including \0.  */
  93. #define MAXPATH     80                  /* input maximum */
  94. #define MAXDRIVE    3
  95. #define MAXDIR      66
  96. #define MAXFILE     9
  97. #define MAXEXT      5
  98.  
  99. /*  Bit masks for fnsplitE() return value  */
  100. #define WILDCARDS   0x01                /* '*' and/or '?' in filename or ext */
  101. #define EXTENSION   0x02                /* extension present */
  102. #define FILENAME    0x04                /* filename present */
  103. #define DIRECTORY   0x08                /* directory present */
  104. #define DRIVE       0x10                /* drive: present */
  105. /*  Bit masks for returning truncation errors in fnsplitE()  */
  106. #define PATHt       0x0100              /* input path truncated */
  107. #define EXTENSIONt  (EXTENSION << 8)    /* extension truncated */
  108. #define FILENAMEt   (FILENAME << 8)     /* filename truncated */
  109. #define DIRECTORYt  (DIRECTORY << 8)    /* directory truncated */
  110. #define DRIVEt      (DRIVE << 8)        /* drive truncated (can't happen) */
  111. #define FNSPLITEt   (PATHt | EXTENSIONt | FILENAMEt | DIRECTORYt | DRIVEt)
  112.                                         /* all of the above */
  113.  
  114. /*  Function prototypes  */
  115. int expandwild (int *, char **[], int, char *[], int);
  116. int fnsplitE (char *, char *, char *, char *, char *);
  117. int fnsplitEa (char *, char *, char *, unsigned int, int);
  118.  
  119. /*  Codes returned for errors detected by expandwild().
  120.     (Remember to update rmsg[] in main() if these codes are changed.)  */
  121.  
  122. #define EXWINOMEM   1               /* not enough memory */
  123. #define EXWICNTCHG  2               /* count changed between passes */
  124. #define EXWISIZCHG  3               /* array size changed between passes */
  125.  
  126. /*---------------------------------------------------------------------------*/
  127.  
  128. int expandwild(int *pnOut,          /* ptr to no. of strings in output array */
  129. char **pvOut[],                     /* ptr to output array */
  130. int nIn,                            /* no. of strings in vIn */
  131. char *vIn[],                        /* input string array */
  132. int attrib)                         /* file attribute byte */
  133. {
  134.     char drive[MAXDRIVE];           /* fnsplitE() workarea */
  135.     char dir[MAXDIR];               /* fnsplitE() workarea */
  136.     #if !defined(OS2)               /* use DOS directory search */
  137.     struct find_t fblk;             /* for _dos_findfirst()/_dos_findnext() */
  138.     #else                           /* use OS/2 directory search */
  139.     BYTE bMachineMode;              /* for DosGetMachineMode() */
  140.     FILEFINDBUF fblk;               /* for DosFindFirst()/DosFindNext() */
  141.     HDIR hDir;                      /* handle for directory search */
  142.     USHORT usSrchCnt;               /* count: elements in fblk */
  143.     #endif
  144.     char *pvIn;                     /* work ptr into vIn[] */
  145.     char **vOut = NULL;             /* anchor for new output array */
  146.     char *vOutEnd;                  /* last byte of new array */
  147.     char *pvTmp;                    /* temp ptr to vOut[] */
  148.     unsigned int iIn;               /* index into vIn[] */
  149.     unsigned int vOutSize;          /* accumulate memory size of new array */
  150.     unsigned int nOut;              /* count strings in new array */
  151.     unsigned int iOut;              /* string index in new array */
  152.     unsigned int fixSize;           /* size of fixed part of a new string */
  153.     int fnsFlg;                     /* flags returned by fnsplitE() */
  154.     int err = 0;                    /* error code returned by expandwild() */
  155.  
  156.     vOutSize = sizeof(pvOut[0]);    /* space for NULL ptr in new array */
  157.  
  158.     #if defined(OS2)
  159.     DosGetMachineMode(&bMachineMode); /* returns MODE_PROTECTED or MODE_REAL */
  160.     #endif  /* #if defined(OS2) */
  161.  
  162.     /*  Determine no. and total size of strings required for new array.  */
  163.     for (nOut = 0, iIn = 0;
  164.       (pvIn = vIn[iIn]) != NULL && (nIn < 0 || (nIn >= 0 && iIn < nIn));
  165.       iIn++) {
  166.         /*  If no truncation and if a wildcard and if a file name is found,
  167.             save space for expanded filename string.  */
  168.         #if !defined(OS2)           /* DOS-only functions for finding files */
  169.         if (!((fnsFlg = fnsplitE(pvIn, drive, dir, NULL, NULL)) & FNSPLITEt)
  170.           && fnsFlg & WILDCARDS && !_dos_findfirst(pvIn, attrib, &fblk)) {
  171.             fixSize = sizeof(pvOut[0]) + strlen(drive) + strlen(dir) + 1;
  172.             do {
  173.                 nOut++;
  174.                 vOutSize += fixSize + strlen(fblk.name);
  175.             } while (!_dos_findnext(&fblk));
  176.         }
  177.         #else                       /* OS/2 functions for finding files */
  178.         /*  Set hDir based on mode, so protected mode can multithread. */
  179.         if (bMachineMode == MODE_PROTECTED)
  180.             hDir = HDIR_CREATE;     /* so protected mode can multithread */
  181.         else                        /* bMachineMode == MODE_REAL */
  182.             hDir = HDIR_SYSTEM;     /* required for DOS directory search */
  183.         usSrchCnt = 1;              /* initialize count */
  184.         if (!((fnsFlg = fnsplitE(pvIn, drive, dir, NULL, NULL)) & FNSPLITEt)
  185.           && fnsFlg & WILDCARDS
  186.           && !DosFindFirst(pvIn, &hDir, attrib, &fblk, sizeof(fblk),
  187.                 &usSrchCnt, 0L)) /* open handle, find 1st file */ {
  188.             fixSize = sizeof(pvOut[0]) + strlen(drive) + strlen(dir) + 1;
  189.             do {
  190.                 nOut++;
  191.                 vOutSize += fixSize + strlen(fblk.achName);
  192.             } while (!DosFindNext(hDir, &fblk, sizeof(fblk), &usSrchCnt));
  193.             DosFindClose(hDir);     /* close directory search handle */
  194.         }
  195.         #endif  /* #if !defined(OS2) */
  196.         else {                      /* save space for non-expanded string */
  197.             nOut++;
  198.             vOutSize += sizeof(pvOut[0]) + strlen(pvIn) + 1;
  199.         }
  200.     }   /* for (iIn = 0; nOut = 0; ... ) */
  201.  
  202.     /*  Note that the logic above and below does not call DosFindClose() when
  203.         DosFindFirst() returns an error code.  This appears to be ok in v1.1
  204.         of OS/2 as DosFindFirst() returns an invalid handle which cannot be
  205.         closed anyway.  But you might watch it in future releases.  */
  206.  
  207.     /*  Allocate memory for new array.  */
  208.     if ((vOut = (char **) malloc(vOutSize)) == NULL)
  209.         err = EXWINOMEM;                            /* not enough memory */
  210.     else {
  211.         vOut[0] = (char *) (vOut + nOut + 1);       /* ptr to 1st string */
  212.         vOutEnd = (char *) vOut + vOutSize;         /* 1st byte after last */
  213.     }
  214.  
  215.     /*  Go through again and copy strings to new array.  */
  216.     for (iOut = 0, iIn = 0; err == 0
  217.       && (pvIn = vIn[iIn]) != NULL && (nIn < 0 || (nIn >= 0 && iIn < nIn));
  218.       iIn++) {
  219.         /*  If no truncation and if wildcard and if file name is found,
  220.             save expanded string.  */
  221.         #if !defined(OS2)           /* DOS-only functions for finding files */
  222.         if (!((fnsFlg = fnsplitE(pvIn, drive, dir, NULL, NULL)) & FNSPLITEt)
  223.           && fnsFlg & WILDCARDS && !_dos_findfirst(pvIn, attrib, &fblk)) {
  224.             fixSize = strlen(drive) + strlen(dir) + 1;
  225.             do {
  226.                 if (iOut >= nOut)               /* count changed? */
  227.                     err = EXWICNTCHG;           /* 2nd pass count too big */
  228.                 else {
  229.                     pvTmp = vOut[iOut];
  230.                     if (pvTmp + fixSize + strlen(fblk.name) > vOutEnd)
  231.                         err = EXWISIZCHG;       /* overflow */
  232.                     else    /* copy full name, save ptr to next new string */
  233.                         vOut[++iOut] = 1 +      /* whew! */
  234.                           stpcpy(stpcpy(stpcpy(pvTmp,drive),dir),fblk.name);
  235.                 }
  236.             } while (err == 0 && !_dos_findnext(&fblk));
  237.         }
  238.         #else                           /* OS/2 functions for finding files */
  239.         /*  Set hDir based on mode, so protected mode can multithread. */
  240.         if (bMachineMode == MODE_PROTECTED)
  241.             hDir = HDIR_CREATE;         /* so protected mode can multithread */
  242.         else                            /* bMachineMode == MODE_REAL */
  243.             hDir = HDIR_SYSTEM;         /* required for DOS directory search */
  244.         usSrchCnt = 1;                  /* initialize count */
  245.         if (!((fnsFlg = fnsplitE(pvIn, drive, dir, NULL, NULL)) & FNSPLITEt)
  246.           && fnsFlg & WILDCARDS
  247.           && !DosFindFirst(pvIn, &hDir, attrib, &fblk, sizeof(fblk),
  248.                 &usSrchCnt, 0L)) /* re-open handle, find 1st file */ {
  249.             fixSize = strlen(drive) + strlen(dir) + 1;
  250.             do {
  251.                 if (iOut >= nOut)               /* count changed? */
  252.                     err = EXWICNTCHG;           /* 2nd pass count too big */
  253.                 else {
  254.                     pvTmp = vOut[iOut];
  255.                     if (pvTmp + fixSize + strlen(fblk.achName) > vOutEnd)
  256.                         err = EXWISIZCHG;       /* overflow */
  257.                     else    /* copy full name, save ptr to next new string */
  258.                         vOut[++iOut] = 1 +      /* whew! */
  259.                           stpcpy(stpcpy(stpcpy(pvTmp,drive),dir),fblk.achName);
  260.                 }
  261.             } while (err == 0
  262.                 && !DosFindNext(hDir, &fblk, sizeof(fblk), &usSrchCnt));
  263.             DosFindClose(hDir);         /* close directory search handle */
  264.         }
  265.         #endif  /* #if !defined(OS2) */
  266.         else {                          /* copy non-wildcard to new array */
  267.             if (iOut >= nOut)           /* count changed? */
  268.                 err = EXWICNTCHG;       /* 2nd pass count too big */
  269.             else {
  270.                 pvTmp = vOut[iOut];
  271.                 if (pvTmp + strlen(pvIn) + 1 > vOutEnd)
  272.                     err = EXWISIZCHG;   /* overflow */
  273.                 else        /* copy non-wildcard, save ptr to next new string*/
  274.                     vOut[++iOut] = 1 + stpcpy(pvTmp, pvIn);
  275.             }
  276.         }
  277.     }   /* for (iIn = 0; iOut = 0; ... ) */
  278.  
  279.     if (err == 0)
  280.         /*  Check for changes in count or size between 2 passes thru names.  */
  281.         if (iOut != nOut)               /* count changed? */
  282.             err = EXWICNTCHG;           /* 2nd pass count smaller */
  283.         else if (vOut[nOut] != vOutEnd) /* size changed? */
  284.             err = EXWISIZCHG;           /* 2nd pass size smaller */
  285.  
  286.     if (err == 0) {                 /* if no error, return results to caller */
  287.         vOut[nOut] = NULL;          /* terminate array as per ANSI standard  */
  288.         *pnOut = nOut;
  289.         *pvOut = vOut;
  290.     }
  291.     else if (vOut != NULL)
  292.         free((char *) vOut);
  293.  
  294.     return (err);
  295.  
  296. }   /* expandwild() */
  297.  
  298. /*---------------------------------------------------------------------------*/
  299.  
  300. /*  fnsplitE():
  301.     Split full file name path string into component parts--drive, directory,
  302.     file name, and file name extension.  Returns bit flags indicating which
  303.     parts are in the input and whether any input was truncated because it is
  304.     too long.  This is a work-alike function of fnsplit() in Turbo C 1.0 except
  305.     the latter does not indicate truncation errors.  */
  306.  
  307. int fnsplitE(char *path,        /* input path       */
  308. char *drive,                    /* output drive     */
  309. char *dir,                      /* output directory */
  310. char *name,                     /* output file name */
  311. char *ext)                      /* output file name extension */
  312. {
  313.     int flags = 0;              /* bit flags return value */
  314.     char *pL, *pR;              /* Left & Right-hand ptrs into path */
  315.     unsigned int nchar;         /* no. of characters */
  316.  
  317.     /*  Initialize output to null strings where present in case component
  318.         absent in input.  */
  319.     if (drive != NULL)        *drive = '\0';
  320.     if (dir   != NULL)        *dir   = '\0';
  321.     if (name  != NULL)        *name  = '\0';
  322.     if (ext   != NULL)        *ext   = '\0';
  323.  
  324.     while (*path == ' ')        /* skip any leading spaces in input */
  325.         ++path;
  326.  
  327.     /*  Truncate input if too long.
  328.         (Turbo C fnsplit() uses MAXPATH, not MAXPATH - 1.)   */
  329.     if ((nchar = strlen(path)) > MAXPATH - 1) {
  330.         nchar = MAXPATH - 1;
  331.         flags |= PATHt;         /* indicate truncation error */
  332.     }
  333.     /*  Return if path null; only needed if path at segment offset 0. */
  334.     if (nchar == 0)
  335.         return(flags);
  336.  
  337.     /*  Initialize current Left and Right ends to the terminal \0.  */
  338.     pL = pR = path + nchar;
  339.  
  340.     /*  Reverse scan thru input path string.  */
  341.     while (--pL >= path) {
  342.  
  343.         /*  Check for special character in input path string.  */
  344.         switch (*pL) {
  345.             case '.':           /* possible left-most char of extension */
  346.                 /*  Extension, only if we're not already past it.  */
  347.                 if (!(flags & (DRIVE | DIRECTORY | FILENAME | EXTENSION))) {
  348.                     flags |= fnsplitEa(pL, pR, ext, MAXEXT - 1, EXTENSION);
  349.                     pR = pL;
  350.                 }
  351.                 break;
  352.             case '*':           /* wildcard if in filename or extension */
  353.             case '?':
  354.                 if (!(flags & (DRIVE | DIRECTORY)))
  355.                     flags |= WILDCARDS;
  356.                 break;
  357.             case '\\':          /* possible directory indication */
  358.             case '/':
  359.                 if (!(flags & (DRIVE | DIRECTORY | FILENAME))) {
  360.                     flags |= fnsplitEa(++pL, pR, name, MAXFILE - 1, FILENAME);
  361.                     pR = pL--;
  362.                 }
  363.                 if (!(flags & (DRIVE | DIRECTORY)))
  364.                     flags |= DIRECTORY;
  365.                 break;
  366.             case ':':           /* right-most char of 2-char drive? */
  367.                 if (pL == path + 1) {   /* colon must be here to be a drive */
  368.                     if (!(flags & (DRIVE | DIRECTORY | FILENAME))) {
  369.                         flags |= fnsplitEa(++pL, pR, name, MAXFILE - 1,
  370.                           FILENAME);
  371.                         pR = pL--;
  372.                     }
  373.                     else if (flags & DIRECTORY) {
  374.                         flags |= fnsplitEa(++pL, pR, dir, MAXDIR - 1,
  375.                           DIRECTORY);
  376.                         pR = pL--;
  377.                     }
  378.                     flags |= DRIVE;
  379.                 }
  380.         }   /* switch (*pL) */
  381.  
  382.         /*  If back to start of input string, deal with input that remains.  */
  383.         if (pL == path) {
  384.             if (!(flags & (DRIVE | DIRECTORY | FILENAME)))
  385.                 flags |= fnsplitEa(pL, pR, name, MAXFILE - 1, FILENAME);
  386.             else if (flags & DRIVE)
  387.                 flags |= fnsplitEa(pL, pR, drive, MAXDRIVE - 1, DRIVE);
  388.             else                /* only dir remains */
  389.                 flags |= fnsplitEa(pL, pR, dir, MAXDIR - 1, DIRECTORY);
  390.             break;              /* stop loop if path segment offset == 0 */
  391.         }
  392.  
  393.     }   /* while (--pL >= path) */
  394.  
  395.     return (flags);
  396.  
  397. }   /* fnsplitE() */
  398.  
  399. /*  fnsplitEa() copies string to output using left/right ptrs to input. */
  400.  
  401. int fnsplitEa(char *pL,         /* Left-hand ptr to input */
  402. char *pR,                       /* Right-hand ptr to input */
  403. char *pOut,                     /* ptr to output, can be NULL */
  404. unsigned int maxOut,            /* max non-null char to *pOut excluding \0 */
  405. int flag)                       /* fnsplitE() flag bit */
  406. {
  407.     unsigned int nchar;         /* no. of characters */
  408.  
  409.     if ((nchar = pR - pL) > maxOut) {   /* too long for output? */
  410.         nchar = maxOut;                 /* yes, truncate */
  411.         flag |= flag << 8;              /* indicate truncation to caller */
  412.     }
  413.     if (pOut != NULL) {                 /* any output area? */
  414.         strncpy(pOut, pL, nchar);       /* copy to output */
  415.         *(pOut + nchar) = '\0';         /* terminal \0 */
  416.     }
  417.  
  418.     return (nchar > 0 ? flag : 0);      /* return flag if input not empty */
  419.  
  420. }   /* fnsplitEa() */
  421.  
  422. /*---------------------------------------------------------------------------*/
  423.  
  424. #if defined(MAIN)
  425.  
  426. /*  main() test driver for expandwild().  */
  427.  
  428. /*  File attributes a-la MSC for TC or for use with OS/2  */
  429. #if defined(__TURBOC__) || defined(OS2)
  430. #define _A_NORMAL   0x00                /* Normal file--no attribute bits */
  431. #define _A_RDONLY   0x01                /* Read only attribute */
  432. #define _A_HIDDEN   0x02                /* Hidden file */
  433. #define _A_SYSTEM   0x04                /* System file */
  434. #define _A_VOLID    0x08                /* Volume label--ignored for OS/2 */
  435. #define _A_SUBDIR   0x10                /* Subdirectory */
  436. #define _A_ARCH     0x20                /* Archive */
  437. #endif  /* #if defined(__TURBOC__) */
  438.  
  439. #if defined(OS2)
  440. #define _A_ALLBITS  (_A_RDONLY|_A_HIDDEN|_A_SYSTEM|         _A_SUBDIR|_A_ARCH)
  441. #else
  442. #define _A_ALLBITS  (_A_RDONLY|_A_HIDDEN|_A_SYSTEM|_A_VOLID|_A_SUBDIR|_A_ARCH)
  443. #endif
  444.  
  445. unsigned int xtoi(char []);
  446.  
  447. int main(int argc,
  448. char *argv[])                   /* argv[1] is attribute byte in ASCII hex */
  449. {
  450.     unsigned int attrib;        /* attribute byte from argv[1] via xtoi() */
  451.     int i;                      /* argv/newargv index */
  452.     int rc;                     /* return code from expandwild() */
  453.     int newargc;                /* count of expanded arg strings */
  454.     char **newargv;             /* ptr to new array of expanded arg strings */
  455.  
  456.     /*  Msgs for errors detected by expandwild().  */
  457.     static char *rmsg[] = {
  458.         "successful",                                   /* 0 */
  459.         "not enough memory for output",                 /* 1 EXWINOMEM */
  460.         "output count change between passes",           /* 2 EXWICNTCHG */
  461.         "output size change between passes"             /* 3 EXWISIZCHG */
  462.     };
  463.  
  464.     #if !defined(__TURBOC__)
  465.         static char compiler[] = "Microsoft C";
  466.     #if defined(M_I86SM)
  467.         static char model[] = "small model";
  468.     #elif defined(M_I86MM)
  469.         static char model[] = "medium model";
  470.     #elif defined(M_I86CM)
  471.         static char model[] = "compact model";
  472.     /*  Test M_I86HM before M_I86LM because both defined in huge model.  */
  473.     #elif defined(M_I86HM)
  474.         static char model[] = "huge model";
  475.     #elif defined(M_I86LM)
  476.         static char model[] = "large model";
  477.     #endif
  478.  
  479.     #else
  480.         static char compiler[] = "Turbo C";
  481.     #if defined(__TINY__)
  482.         static char model[] = "tiny model";
  483.     #elif defined(__SMALL__)
  484.         static char model[] = "small model";
  485.     #elif defined(__MEDIUM__)
  486.         static char model[] = "medium model";
  487.     #elif defined(__COMPACT__)
  488.         static char model[] = "compact model";
  489.     #elif defined(__LARGE__)
  490.         static char model[] = "large model";
  491.     #elif defined(__HUGE__)
  492.         static char model[] = "huge model";
  493.     #endif
  494.     #endif
  495.  
  496.     fprintf(stderr, "Test expandwild(), %s %s"
  497.         #if defined(OS2)
  498.         " (OS/2)"
  499.         #endif
  500.         "\n", compiler, model);
  501.  
  502.     /*  Check range of no. of args and value of attribute byte.  */
  503.     if (argc < 2 || (attrib = xtoi(argv[1])) == 0xffff
  504.       || attrib & (_A_ALLBITS ^ 0xffff)) {
  505.         printf("\nUsage:  expandwi attrib [filespec [filespec] ...]\n");
  506.         printf("        where attrib is file attribute byte in hex.\n");
  507.         return (255);
  508.     }
  509.  
  510.     printf("\nFile names requested with attribute byte of 0x%X\n", attrib);
  511.  
  512.     printf("\nexpandwild() input strings (count = %d)\n", argc - 2);
  513.     for (i = 2; i < argc; i++)
  514.         printf("  %s\n", argv[i]);
  515.  
  516.     rc = expandwild(&newargc, &newargv, -1, &argv[2], attrib);
  517.  
  518.     printf("\nexpandwild() return code = %d (%s)\n", rc, rmsg[rc]);
  519.  
  520.     if (rc == 0) {
  521.         printf("\nexpandwild() expanded output strings (count = %d)\n",
  522.           newargc);
  523.         for (i = 0; i < newargc; i++)
  524.             printf("  %s\n", newargv[i]);
  525.     }
  526.  
  527.     return (rc);
  528.  
  529. }   /* main() */
  530.  
  531.  
  532. /*  Convert ASCII string of hex digits to int.  Return 0xffff if invalid digits
  533.     or overflow detected; warning: also returned for ASCII string "FFFF".  */
  534.  
  535. #include <ctype.h>
  536.  
  537. unsigned int xtoi(char x[])     /* x is input ASCII hex string, can be null */
  538. {
  539.     unsigned int xw;            /* work area for current hex digit */
  540.     unsigned int ix = 0;        /* return value accumulator */
  541.  
  542.     for (; *x != '\0'; ++x) {
  543.         if (!isascii(xw = *x))
  544.             return (0xffff);    /* invalid digit */
  545.         xw = toupper(xw);
  546.         if (xw >= '0' && xw <= '9')
  547.             xw -= '0';
  548.         else if (xw >= 'A' && xw <= 'F')
  549.             xw -= 'A' - 0xA;
  550.         else
  551.             return (0xffff);    /* invalid digit */
  552.         if (ix < 0x1000) {      /* overflow? */
  553.             ix <<= 4;           /* make room for current digit */
  554.             ix |= xw;           /* add current digit */
  555.         }
  556.         else
  557.             return (0xffff);    /* overflow */
  558.     }
  559.  
  560.     return (ix);
  561.  
  562. }   /* xtoi() */
  563.  
  564. #endif  /* #if defined(MAIN) */
  565.  
  566. /*---------------------------------------------------------------------------*/
  567.